/**
 * Created by chenweiwei on 2019/3/29.
 *
 */

//  函数在一段时间内多次触发只会执行第一次，用于阻止按钮多次点击跳转等情况
export function throttle(fn, gapTime) {
    if (gapTime == null || gapTime == undefined) {
        gapTime = 1500
    }

    let _lastTime = null

    // 返回新的函数
    return function () {
        let _nowTime = + new Date()
        if (_nowTime - _lastTime > gapTime || !_lastTime) {
            fn.apply(this, arguments)   //将this和参数传给原函数
            _lastTime = _nowTime
        }
    }
}
/**
 * @desc 函数防抖
 * @param func 函数
 * @param wait 延迟执行毫秒数
 * @param immediate true 表立即执行，false 表非立即执行
 */

export function debounce(func,wait=1000,immediate) {
    let timeout;

    return function () {
        let context = this;
        let args = arguments;

        if (timeout) clearTimeout(timeout);
        if (immediate) {
            var callNow = !timeout;
            timeout = setTimeout(() => {
                timeout = null;
            }, wait)
            if (callNow) func.apply(context, args)
        }
        else {
            timeout = setTimeout(function(){
                func.apply(context, args)
            }, wait);
        }
    }
}
/**
 * 设置监听器
 *
 * page页面中调用
 *
 *  const { setWatcher } = global.$util
 *  setWatcher(this);
 *  watch: {
        my: {
          handler(newValue,oldValue) {
            console.log(newValue);
          },
          deep: true
        }
   },
 */
export function setWatcher(page) {
    let data = page.data;
    let watch = page.watch;
    Object.keys(watch).forEach(v => {
        console.log(v)
        let key = v.split('.'); // 将watch中的属性以'.'切分成数组
        let nowData = data; // 将data赋值给nowData
        for (let i = 0; i < key.length - 1; i++) { // 遍历key数组的元素，除了最后一个！
            nowData = nowData[key[i]]; // 将nowData指向它的key属性对象
        }
        let lastKey = key[key.length - 1];
        // 假设key==='my.name',此时nowData===data['my']===data.my,lastKey==='name'
        let watchFun = watch[v].handler || watch[v]; // 兼容带handler和不带handler的两种写法
        let deep = watch[v].deep; // 若未设置deep,则为undefine
        observe(nowData, lastKey, watchFun, deep, page); // 监听nowData对象的lastKey
    })
}

/**
 * 监听属性 并执行监听函数
 */
function observe(obj, key, watchFun, deep, page) {
    var val = obj[key];
    // 判断deep是true 且 val不能为空 且 typeof val==='object'（数组内数值变化也需要深度监听）
    if (deep && val != null && typeof val === 'object') {
        Object.keys(val).forEach(childKey => { // 遍历val对象下的每一个key
            this.observe(val, childKey, watchFun, deep, page); // 递归调用监听函数
        })
    }
    var that = this;
    Object.defineProperty(obj, key, {
        configurable: true,
        enumerable: true,
        set: function (value) {
            // 用page对象调用,改变函数内this指向,以便this.data访问data内的属性值
            watchFun.call(page, value, val); // value是新值，val是旧值
            val = value;
            if (deep) { // 若是深度监听,重新监听该对象，以便监听其属性。
                observe(obj, key, watchFun, deep, page);
            }
        },
        get: function () {
            return val;
        }
    })
}
module.exports = {
    setWatcher: setWatcher,
    throttle:throttle,
    debounce:debounce
}